using System;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Toon.Models.Characters;

namespace Toon.Models.Tests.Characters
{
    public partial class CharacterTests
    {
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Name_PropertyNullAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        try
                        {
                            objectUnderTest.Name = null;
                            Assert.IsNull(objectUnderTest.Name);;
                        }
                        catch (ArgumentNullException)
                        {
                            //OK
                            return;
                        }
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Name_PropertyAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        System.String expectedValue;
                    
                        
                        try
                        {
                            expectedValue = null;
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "x";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = ",";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "123";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "abc";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1,2,3";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a,b,c";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1;2;3";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a;b;c";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "http://test.com";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "test@test.com";
                            objectUnderTest.Name = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Name)) || expectedValue == objectUnderTest.Name);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                    
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Species_PropertyNullAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        try
                        {
                            objectUnderTest.Species = null;
                            Assert.IsNull(objectUnderTest.Species);;
                        }
                        catch (ArgumentNullException)
                        {
                            //OK
                            return;
                        }
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Species_PropertyAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        System.String expectedValue;
                    
                        
                        try
                        {
                            expectedValue = null;
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "x";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = ",";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "123";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "abc";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1,2,3";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a,b,c";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1;2;3";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a;b;c";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "http://test.com";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "test@test.com";
                            objectUnderTest.Species = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Species)) || expectedValue == objectUnderTest.Species);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                    
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Occupation_PropertyNullAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        try
                        {
                            objectUnderTest.Occupation = null;
                            Assert.IsNull(objectUnderTest.Occupation);;
                        }
                        catch (ArgumentNullException)
                        {
                            //OK
                            return;
                        }
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Occupation_PropertyAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        System.String expectedValue;
                    
                        
                        try
                        {
                            expectedValue = null;
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "x";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = ",";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "123";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "abc";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1,2,3";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a,b,c";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1;2;3";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a;b;c";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "http://test.com";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "test@test.com";
                            objectUnderTest.Occupation = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Occupation)) || expectedValue == objectUnderTest.Occupation);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                    
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_NaturalEnemies_PropertyNullAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        try
                        {
                            objectUnderTest.NaturalEnemies = null;
                            Assert.IsNull(objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentNullException)
                        {
                            //OK
                            return;
                        }
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_NaturalEnemies_PropertyAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        System.String expectedValue;
                    
                        
                        try
                        {
                            expectedValue = null;
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "x";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = ",";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "123";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "abc";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1,2,3";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a,b,c";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1;2;3";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a;b;c";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "http://test.com";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "test@test.com";
                            objectUnderTest.NaturalEnemies = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.NaturalEnemies)) || expectedValue == objectUnderTest.NaturalEnemies);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                    
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_BeliefsAndGoals_PropertyNullAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        try
                        {
                            objectUnderTest.BeliefsAndGoals = null;
                            Assert.IsNull(objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentNullException)
                        {
                            //OK
                            return;
                        }
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_BeliefsAndGoals_PropertyAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        System.String expectedValue;
                    
                        
                        try
                        {
                            expectedValue = null;
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "x";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = ",";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "123";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "abc";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1,2,3";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a,b,c";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1;2;3";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a;b;c";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "http://test.com";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "test@test.com";
                            objectUnderTest.BeliefsAndGoals = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.BeliefsAndGoals)) || expectedValue == objectUnderTest.BeliefsAndGoals);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                    
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Description_PropertyNullAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        try
                        {
                            objectUnderTest.Description = null;
                            Assert.IsNull(objectUnderTest.Description);;
                        }
                        catch (ArgumentNullException)
                        {
                            //OK
                            return;
                        }
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_Description_PropertyAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        System.String expectedValue;
                    
                        
                        try
                        {
                            expectedValue = null;
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "x";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = ",";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "123";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "abc";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1,2,3";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a,b,c";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "1;2;3";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "a;b;c";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "http://test.com";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = "test@test.com";
                            objectUnderTest.Description = expectedValue;
                            Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.Description)) || expectedValue == objectUnderTest.Description);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                    
                    }    
                    
                    
                    
                    [TestMethod]
                    public void CharacterTests_Property_HitPoints_PropertyAssigned ()
                    {
                        var objectUnderTest = CreateObject();
                        System.Int32 expectedValue;
                    
                        
                        try
                        {
                            expectedValue = Int32.MinValue;
                            objectUnderTest.HitPoints = expectedValue;
                            Assert.AreEqual(expectedValue, objectUnderTest.HitPoints);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = (System.Int32)(-1);
                            objectUnderTest.HitPoints = expectedValue;
                            Assert.AreEqual(expectedValue, objectUnderTest.HitPoints);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = (System.Int32)0;
                            objectUnderTest.HitPoints = expectedValue;
                            Assert.AreEqual(expectedValue, objectUnderTest.HitPoints);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = (System.Int32)1;
                            objectUnderTest.HitPoints = expectedValue;
                            Assert.AreEqual(expectedValue, objectUnderTest.HitPoints);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                        
                        try
                        {
                            expectedValue = Int32.MaxValue;
                            objectUnderTest.HitPoints = expectedValue;
                            Assert.AreEqual(expectedValue, objectUnderTest.HitPoints);;
                        }
                        catch (ArgumentException)
                        {
                            //OK
                            return;
                        }
                        
                    
                    }    
                    
    }
}

